home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C ++ / Applications / Venus 3.5 / FlightWindow.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1997-04-10  |  9.4 KB  |  317 lines  |  [TEXT/CWIE]
  1. /*
  2.  ***********************************************************************
  3.  *
  4.  *                    Implementations of the FlightWindow
  5.  * a live (animated) window that displays the FlightView and tells it to move on
  6.  * 
  7.  ***********************************************************************
  8.  */
  9.  
  10. #include "FlightWindow.h"
  11. #include <Palettes.h>
  12. #include "EventHandlers.h"
  13.  
  14. FlightWindow::FlightWindow(const ElevationMap& image_map, const int wind_id)
  15.     : ScreenWindow(wind_id),
  16.       viewer(image_map),
  17.       proj_parameters(ScreenWindow::q_bounds()),    // Order! proj_parameters is used at view_buffer init...
  18.       view_buffer(image_map,viewer,proj_parameters),
  19.       is_flying(FALSE),
  20.       was_QD_optimized(FALSE)
  21. {}
  22.  
  23. FlightWindow::FlightWindow(const ElevationMap& image_map, const int wind_id,
  24.                            ScreenRect buffer_rect)
  25.     : ScreenWindow(wind_id),
  26.       viewer(image_map),
  27.       proj_parameters(buffer_rect),
  28.       view_buffer(image_map,viewer,proj_parameters),
  29.       is_flying(FALSE),
  30.       was_QD_optimized(FALSE)
  31. {}
  32.  
  33.                         // Post- (but still is a) constructor
  34. void FlightWindow::init(void)
  35. {
  36.   setup_color_env(view_buffer);
  37.   view_buffer.project();
  38.   ScreenWindow::init();
  39. }
  40.  
  41.                     // Negotiate color environment for displaying clouds...
  42. void FlightWindow::setup_color_env(OffScreenBuffer& offscreen_buffer)
  43. {
  44.   set_private_palette(offscreen_buffer.q_clut());
  45.   was_QD_optimized = offscreen_buffer.optimize_color_worlds(GetGDevice());
  46. }
  47.  
  48.                             // How many marks were made per second
  49. int StopWatch::marks_per_sec(void) const
  50. {
  51.   const int time_elapsed = (time_stopped == 0 ? TickCount() : time_stopped) 
  52.                              - time_started;    // in Ticks
  53.   return time_elapsed == 0 ? 0 : (60*mark_counter)/time_elapsed;
  54. }
  55.  
  56.                     // Window functions
  57.                     
  58. void FlightWindow::draw(void)            // It is this function that really draws smth
  59. { 
  60.   //view_buffer.draw(q_bounds());
  61.   {                                        // This is a little bit faster method, works only
  62.                                           // if we blit to the whole window;
  63.                                           // view_buffer.draw(q_bounds()); works even if
  64.                                           // we blit to a user-item control within a dialog
  65.                                           // window
  66.     PixMapHandle pixmap = view_buffer.get_pixmap();
  67.     assert( LockPixels(pixmap) );
  68.     Rect& pixmap_rect = (**pixmap).bounds;
  69.     CopyBits((const BitMap *)*pixmap, &qd.thePort->portBits, &pixmap_rect, 
  70.           q_bounds(), /*ditherCopy*/ srcCopy, nil);
  71.     UnlockPixels(pixmap);
  72.   }
  73.   animate();
  74. }
  75.  
  76.  
  77. Boolean FlightWindow::handle_mouse_down(const EventRecord& the_event, WindowPtr where_window, short window_part)
  78. {
  79.   switch(window_part)
  80.   {
  81.     case inContent:
  82.          return track_mouse(the_event.where);
  83.   
  84.     case inZoomOut:
  85.           return EventHandler::put_back_my_event(EventHandler::zoom_requested),
  86.                     false;
  87.                     
  88.     case inGrow:
  89.            {
  90.            // SetPort(twindow);
  91.            Rect growth_limits = qd.screenBits.bounds;
  92.            growth_limits.left = 64;        // minimal allowed window size
  93.            growth_limits.top = 64;
  94.            DrawGrowIcon (where_window);
  95.            const long new_win_dims =
  96.                 ::GrowWindow(where_window, the_event.where, &growth_limits);
  97.            if( new_win_dims == 0 )    // resize was canceled: merely redraw the window
  98.                return refresh(), true;
  99.  
  100.            Point topleft = {0,0};    // Current window location
  101.            LocalToGlobal(&topleft);        // .. in global coordinates
  102.            EventHandler::put_back_my_event(EventHandler::resize_requested,
  103.                                            new_win_dims,topleft);
  104.            return false;
  105.            }
  106.  
  107.   default:
  108.          break;
  109.   }
  110.   return ScreenWindow::handle_mouse_down(the_event,where_window,window_part);
  111. }
  112.  
  113. Boolean FlightWindow::handle_null_event(const long event_time)
  114. {
  115.   if( !is_flying )
  116.     start_flight();
  117.   return TRUE;
  118. }
  119.  
  120.                             // Handles key_down & auto_key events
  121. Boolean FlightWindow::handle_key_down(const EventRecord& the_event)
  122. {
  123.   //_error("char pressed %ld",the_event.message & charCodeMask);
  124.   stop_flight();                        // The user wanted to take an active role
  125.   switch(the_event.message & charCodeMask)
  126.   {
  127.     case 11:                // PgUp
  128.          if( the_event.modifiers & optionKey )
  129.            proj_parameters.climb(1);
  130.          else
  131.            proj_parameters.move_horizon(4);
  132.          break;
  133.              
  134.     case 12:                // PgDn
  135.          if( the_event.modifiers & optionKey )
  136.            proj_parameters.climb(-1);
  137.          else
  138.            proj_parameters.move_horizon(-4);
  139.          break;
  140.         
  141.     case 30:                // Arrow Up
  142.          viewer.move_ver(2);
  143.          break;
  144.              
  145.     case 31:                // Arrow Down
  146.          viewer.move_ver(-2);
  147.          break;
  148.  
  149.     case 28:                // Arrow Left
  150.          viewer.move_hor(-4);
  151.          break;
  152.  
  153.     case 29:                // Arrow Right
  154.          viewer.move_hor(4);
  155.          break;
  156.  
  157.     case 'z':
  158.          proj_parameters.zoom(-1);
  159.          break;
  160.      
  161.     case 'Z':
  162.          proj_parameters.zoom(1);
  163.          break;
  164.          
  165.     case 'D':
  166.          view_buffer.dump();
  167.          message("\n\nAnimation speed %d frames/sec\n",frame_counter.marks_per_sec());
  168.          message("\nQuickDraw drawing %s optimized\n",
  169.                   was_QD_optimized ? "WAS" : "was NOT");
  170.          return FALSE;
  171.  
  172.     default:                // Get the parent to handle the other keys: 
  173.          return ScreenWindow::handle_key_down(the_event);    // he'll probably kill the application
  174.   }
  175.   view_buffer.project();
  176.   refresh();
  177.   return TRUE;
  178. }
  179.  
  180.                                 // Track the mouse clicked in content
  181.                                 // and move the plane as the mouse (still down) moves
  182. Boolean  FlightWindow::track_mouse(Point mouse_down_pt)
  183. {
  184.   Point prev_point = mouse_down_pt;        // In _global_ coordinates!
  185.   stop_flight();
  186.   
  187.   EventRecord new_event;
  188.   while( !OSEventAvail(mUpMask,&new_event) )
  189.   {
  190.     const int delta_x = prev_point.h - new_event.where.h;
  191.     const int delta_y = prev_point.v - new_event.where.v;
  192.     prev_point = new_event.where;
  193.     
  194.       if( abs(delta_x) < 2 && abs(delta_y) < 2 )
  195.         continue;                            // Ignore mouse dribble....
  196.         
  197.       viewer.move_ver(delta_y);
  198.       viewer.move_hor(delta_x);
  199.     view_buffer.project();
  200.     refresh();
  201.     draw_immediately();
  202.   }
  203.   return TRUE;
  204. }
  205.  
  206.                             // Dealing with viewer position (and animating it)
  207. FlightWindow::ViewerAnim::ViewerAnim(const ScreenRect& rect)
  208.   : ViewerPosition(rect.q_width()/2,0,0,g_unit),
  209.     sup_xe(rect.q_width()),
  210.     sup_ye(rect.q_height())
  211. {
  212. }
  213.  
  214.                                 // move things a little
  215. void FlightWindow::ViewerAnim::stir(void)
  216. {
  217.   move_hor(4);
  218.   move_ver(4);
  219. }
  220.  
  221.                                 // Commencing and terminating the flight
  222. void FlightWindow::start_flight(void)
  223. {
  224.   is_flying = TRUE;
  225.   refresh();
  226.   frame_counter.start();
  227. }
  228.  
  229. void FlightWindow::stop_flight(void)
  230. {
  231.   is_flying = FALSE;
  232.   frame_counter.stop();
  233. }
  234.  
  235.                                 // Move things a little
  236.                                 // (usually called within draw())
  237. void FlightWindow::animate(void)
  238. {
  239.   if( !is_flying )
  240.     return;
  241.   viewer.stir();
  242.   view_buffer.project();
  243.   refresh();                            // That would make sure that the next call
  244.                                         // to WaitNextEvent would get another update
  245.   ++frame_counter;
  246. }
  247.  
  248.  
  249. FullFlightWindow::FullFlightWindow(const ElevationMap& image_map, const int wind_id)
  250.     : FlightWindow(image_map,wind_id,qd.screenBits.bounds),
  251.       normal_menu_bar_height(LMGetMBarHeight())
  252. {
  253.   WindowPtr whole_screen_win = our_window();
  254.   assert( whole_screen_win != nil );
  255.   MoveWindow( whole_screen_win, qd.screenBits.bounds.left, qd.screenBits.bounds.top, true );
  256.   SizeWindow( whole_screen_win, qd.screenBits.bounds.right - qd.screenBits.bounds.left,
  257.                         qd.screenBits.bounds.bottom - qd.screenBits.bounds.top, false );
  258.     /****************************************************/
  259.     /* Set the window's visRgn to include the menu bar. */
  260.     /****************************************************/
  261.     
  262.   RectRgn( (*whole_screen_win).visRgn, &qd.screenBits.bounds );
  263.   InvalRect( &qd.screenBits.bounds );
  264.     
  265.     /*************************************************/
  266.     /* Set the global MBarHeight to 0 to prevent any */
  267.     /*    other apps from writing to the menu bar.     */
  268.     /*************************************************/
  269.   LMSetMBarHeight(0);
  270.   ObscureCursor();                        // hide the cursor, use ShieldCursor()???
  271. }
  272.  
  273.         // Make sure we restore the original Menu Bar height
  274.         // And the gDevice colors we must've screwed up...
  275. void FullFlightWindow::destroy_it(void)
  276. {
  277.   LMSetMBarHeight(normal_menu_bar_height);    // Restore the normal menu bar height
  278.   RestoreDeviceClut(GetGDevice());
  279.   FlightWindow::destroy_it();                // Continue destructing...
  280. }
  281.  
  282. void FullFlightWindow::setup_color_env(OffScreenBuffer& offscreen_buffer)
  283. {
  284.   was_QD_optimized = offscreen_buffer.impose_on_gdevice(GetGDevice());
  285. }
  286.  
  287.  
  288. void FullFlightWindow::draw(void)            // It is this function that really draws smth
  289. { 
  290.   //view_buffer.draw(q_bounds());
  291.   {                                        // This is a little bit faster method, works only
  292.                                           // if we blit to the whole window;
  293.                                           // view_buffer.draw(q_bounds()); works even if
  294.                                           // we blit to a user-item control within a dialog
  295.                                           // window
  296.     PixMapHandle pixmap = get_pixmap();
  297.     assert( LockPixels(pixmap) );
  298.     //GDHandle gd_device = GetGDevice();    // maybe current device?
  299.     //CTabHandle old_ctab = (**pixmap).pmTable;
  300.     //(**pixmap).pmTable = (**(**gd_device).gdPMap).pmTable;
  301.     Rect& pixmap_rect = (**pixmap).bounds;
  302.     //ScreenRect(pixmap_rect).print("pixmap");
  303.     //q_bounds().print("bounds");
  304.     //ScreenRect((**(**gd_device).gdPMap).bounds).print("gd device's rect");
  305.     //_error("done");
  306.       //EraseRect(q_bounds());
  307.     //CopyBits((const BitMap *)*pixmap, (BitMap*)(*(**gd_device).gdPMap), &pixmap_rect, 
  308.      //      &(**(**gd_device).gdPMap).bounds, /*ditherCopy*/ srcCopy, nil);
  309.            // Make sure that rectangles are appropriate!! that same as gdevice's!!!
  310.     CopyBits((const BitMap *)*pixmap, &qd.thePort->portBits, &pixmap_rect, 
  311.           q_bounds(), /*ditherCopy*/ srcCopy, nil);
  312.      //(**pixmap).pmTable = old_ctab;
  313.     UnlockPixels(pixmap);
  314.   }
  315.   animate();
  316. }
  317.